
// 数组打平
export const flattenTree = (treeData,defaultProps) => {
    let flatData = [];
    treeData.forEach(node => {
        flatData.push(node);
        if (node[defaultProps.children]) {
            flatData = flatData.concat(flattenTree(node[defaultProps.children],defaultProps));
        }
    });
    return flatData;
}

// 校验树是否全选
export const checkedAllTrue = (treeRef,treeData,nodeKey,defaultProps) => {
    // 校验是否全选
    const allKeys = treeRef.getCheckedKeys();
    const allNodes = flattenTree(treeData,defaultProps);
    const allKeysSet = new Set(allKeys);
    const allNodesSet = new Set(allNodes.map(node => node[nodeKey]));

    return allKeysSet.size === allNodesSet.size &&
        [...allKeysSet].every(key => allNodesSet.has(key))
}

// 深拷贝
export const deepClone = (obj) => {
    //判断拷贝的obj是对象还是数组
    let objClone = Array.isArray(obj) ? [] : {}
    if (obj && typeof obj === 'object') {
        //obj不能为空，并且是对象或者是数组 因为null也是object
        for (let key in obj) {
            if (obj.hasOwnProperty(key)) {
                if (obj[key] && typeof obj[key] === 'object') {
                    //obj里面属性值不为空并且还是对象，进行深度拷贝
                    objClone[key] = deepClone(obj[key]) //递归进行深度的拷贝
                } else {
                    objClone[key] = obj[key] //直接拷贝
                }
            }
        }
    }
    return objClone
}


// 校验是否树节点是否全部禁用 nodes: []
export const checkAllDisabled = (nodes,defaultProps) => {
    if (!(nodes && Array.isArray(nodes))) return

    for (const node of nodes) {
        // 如果当前节点的disabled不是true，则直接返回false
        if (!node[defaultProps.disabled] ) {
            return false;
        }
        // 如果当前节点有子节点，则递归检查子节点
        if (node[defaultProps.children] && node[defaultProps.children].length > 0) {
            const childrenAreDisabled = checkAllDisabled(node[defaultProps.children],defaultProps);
            // 如果子节点中有任何disabled不是true，则返回false
            if (!childrenAreDisabled) {
                return false;
            }
        }
    }
    // 如果所有节点的disabled都是true，则返回true
    return true;
}

// 设置数组的某个字段值为某个参数
export const setFieldValue = (array, field, value,defaultProps) => {
    // 遍历数组中的每个元素
    array.forEach(item => {
        // 如果元素是对象且有属性，则设置字段值
        if (typeof item === 'object' && item !== null) {
            item[field] = value;
            // 如果元素有子数组，递归调用函数
            if (Array.isArray(item[defaultProps.children])) {
                setFieldValue(item[defaultProps.children], field, value,defaultProps);
            }
        }
    });
}

// 设置禁用
export const setTreeIsDisabled = (data, nodeKeysToDisable,nodeKey,defaultProps, flag = true) => {
    if (!data || !data.length) return
    data.forEach(item => {
        if (nodeKeysToDisable && nodeKeysToDisable.length && nodeKeysToDisable.includes(item[nodeKey])) {
            // 如果当前节点的id主键在要禁用的id主键列表中，设置disabled为true
            item[defaultProps.disabled] = flag;
        }
        // 如果当前节点有children，递归调用函数
        let itemChildren = item[defaultProps.children]
        if (itemChildren && Array.isArray(itemChildren)) {
            setTreeIsDisabled(itemChildren, nodeKeysToDisable, nodeKey,defaultProps,flag);
        }
    });
}

// 获取数组中disabled的节点的Ids
export const getDisabledNodeIds = (nodes,nodeKey,defaultProps) => {
    const disabledIds = [];

    function traverse(node) {
        if (node.disabled) {
            disabledIds.push(node[nodeKey]);
        }
        if (node[defaultProps.children] && node[defaultProps.children].length > 0) {
            node[defaultProps.children].forEach(child => traverse(child));
        }
    }

    nodes.forEach(node => traverse(node));
    return disabledIds;
}

// 递归校验 当子节点全部被禁用时 ，则设置其父节点也禁用
export const updateDisabledStatus = (nodes,defaultProps) => {
    nodes.forEach(node => {
        // 首先检查当前节点是否有子节点
        if (node[defaultProps.children]) {
            // 假设当前节点的所有子节点都是禁用的
            let allChildrenDisabled = true;

            // 递归检查所有子节点的disabled状态
            node[defaultProps.children].forEach(child => {
                // 如果子节点有子节点，递归调用
                if (child[defaultProps.children]) {
                    updateDisabledStatus([child],defaultProps); // 递归更新子节点状态
                }
                // 更新子节点的disabled状态
                child[defaultProps.disabled] = child[defaultProps.children] ? child[defaultProps.children].every(c => c[defaultProps.disabled]) : child[defaultProps.disabled];

                // 如果发现任何一个子节点没有被禁用，更新假设
                if (!child[defaultProps.disabled]) {
                    allChildrenDisabled = false;
                }
            });

            // 更新当前节点的disabled状态
            node[defaultProps.disabled] = allChildrenDisabled;
        }
    });
}

